Nun, die Interrupts sind eine besondere und sehr delikate Form der Programmunterbrechung,

weil sie eben asynchron geschieht.

Und ich hatte schon dazu erwähnt, dass bei solchen asynchronen Programmunterbrechungen

eben dafür Sorge zu tragen ist, dass der Prozessorstatus invariant, grundsätzlich invariant

zu halten ist.

Einfach weil wir nie wissen, wann diese Unterbrechung denn wirklich geschieht.

Und ich habe auch erwähnt, dass dieses Merkmal dieser interruptsähnlichen Betriebssystem

letztendlich zu einem nicht sequenziellen Programm macht, weil typischerweise natürlich

diese Interrupt-Behandlung innerhalb von Betriebssystem durchführen wird.

Und da sind wir beim Thema der Nichtsequenzialität.

Das wollen wir uns mal ein bisschen genauer anschauen, was wir hier für ein Problem eigentlich

haben.

Wir wollen dann sogenannte Wettlaufsituationen begrifflich kennenlernen und beispielhaft

eben auch sehen und dann auch Wege, zumindest das erste einfache Wege identifizieren, wie

man denn praktisch diesen Wettlaufsituationen in Form des Schützens von kritischen Abschnitten

begegnen kann.

Nehmen wir mal ein Beispiel.

Ein sequenzielles Programm, so wie es hier dargestellt ist.

Es ist nun wirklich ein sehr, sehr einfaches und vielleicht auch ein ziemlich dummes Programm,

weil wir haben, letztendlich macht es nichts weiter als fortlaufend doch irgendwelche

Zahlenwerte auszugeben.

Initial ist diese Variable Viel mit Null belegt und hier in der Endlosschleife, in dem Mainprogramm,

haben wir nichts weiter zu tun, als einfach nur zu sagen, wir geben den Wert von Viel

aus und erhöhen den jeweils um 1 und geben dann danach die nächsten Werte aus.

Nun kann man sich die Frage stellen, welche Werte werden dann jetzt in Folge ausgegeben.

Normalerweise würden wir sagen, sind es fortlaufende Werte im Bereich von 0 bis 32 minus 1.

Hier nehmen wir also mal an, dass unser Integer 4-Byte groß ist, 32-Bit letztendlich ausmacht

und damit haben wir halt genau den Wertbereich, der mit diesem Integer abgedeckt wird, also

mit diesem Viel, mit dieser Viel Variablen abgedeckt wird.

Und dann würde es bedeuten, dass unsere Endlosschleife hier fortlaufend einfach schön zählt 0, 1,

2, 3 und so weiter.

Wenn wir 4 Milliarden einmal haben, 2, 32 minus 1 erreicht haben, schlagen wir um 2, 32 entspricht

bei einer 4-Byte Repräsentation, danach dem Wert Null dann entsprechend wieder.

Dann haben wir also einen Überlauf und fangen wieder von vorne an.

So, jetzt nehmen wir doch mal an, dass unser Programm letztendlich ergänzt wird durch

eine Prozedur namens Niamh und die ist dann so formuliert, dass was wir gerade kennengelernt

haben soll hier zum Ausdruck gebracht werden, dass dieses Niamh ein Interabtender ist.

Also wir wollen mal annehmen, dass der Unterprogrammaufruf an Niamh zu unvorhersagbaren Zeitpunkten

letztendlich geschieht einfach deshalb, weil es ein Interabtender ist.

Und wir sehen halt, dass innerhalb dieses Interabtenders eben auch die Variable Wil um

1 hochgezählt wird.

Also wir haben einmal das Hochzählen von Wil hier oben im Hauptprogramm und wir haben

dann halt das Hochzählen von Wil in diesem Unterprogramm Niamh, wobei dieses Unterprogramm

Niamh nicht etwa von dem Hauptprogramm direkt Synchron aufgerufen wird, sondern von einem

externen Prozess von einem Gerät, das in der Lage ist, einen Interabt zu erzeugen,

einfach aktiviert wird.

Und jetzt stellen wir uns die gleiche Frage, welche Werte werden denn jetzt ausgegeben?

Na ja, da können wir jetzt nicht mehr von der Schrittweite 1 sprechen.

Wir müssen einfach annehmen, dann kommt hier so Werte von N raus und dieses N kann zwischen

0 und 2 hoch 32 minus 1 liegen und zwar je nachdem, an Abhängigkeit davon, wie denn der Compiler